package com.ruoyi.collect.service.impl;

import com.ruoyi.collect.domain.CollectBind;
import com.ruoyi.collect.domain.CollectSite;
import com.ruoyi.collect.engine.client.MacCmsApiClient;
import com.ruoyi.collect.engine.client.MacCmsResponse;
import com.ruoyi.collect.mapper.CollectBindMapper;
import com.ruoyi.collect.service.ICollectBindService;
import com.ruoyi.collect.service.ICollectSiteService;
import com.ruoyi.common.utils.DateUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 采集类型绑定服务实现类
 *
 * @author ruoyi
 * @date 2025-11-07
 */
@Service
public class CollectBindServiceImpl implements ICollectBindService {

    private static final Logger log = LoggerFactory.getLogger(CollectBindServiceImpl.class);

    @Autowired
    private CollectBindMapper collectBindMapper;

    @Autowired
    private ICollectSiteService collectSiteService;

    @Autowired
    private MacCmsApiClient macCmsApiClient;

    @Autowired
    private com.ruoyi.basic.service.IColumnService columnService;

    /**
     * 查询采集绑定
     *
     * @param bindId 绑定ID
     * @return 采集绑定
     */
    @Override
    public CollectBind selectCollectBindById(Long bindId) {
        return collectBindMapper.selectCollectBindById(bindId);
    }

    /**
     * 查询采集绑定列表
     *
     * @param collectBind 采集绑定
     * @return 采集绑定列表
     */
    @Override
    public List<CollectBind> selectCollectBindList(CollectBind collectBind) {
        return collectBindMapper.selectCollectBindList(collectBind);
    }

    /**
     * 新增采集绑定
     *
     * @param collectBind 采集绑定
     * @return 结果
     */
    @Override
    public int insertCollectBind(CollectBind collectBind) {
        // 生成绑定键
        String bindKey = collectBind.getSiteFlag() + "_" + collectBind.getRemoteTypeId();
        collectBind.setBindKey(bindKey);
        collectBind.setCreateTime(DateUtils.getNowDate());
        return collectBindMapper.insertCollectBind(collectBind);
    }

    /**
     * 修改采集绑定
     *
     * @param collectBind 采集绑定
     * @return 结果
     */
    @Override
    public int updateCollectBind(CollectBind collectBind) {
        collectBind.setUpdateTime(DateUtils.getNowDate());
        return collectBindMapper.updateCollectBind(collectBind);
    }

    /**
     * 批量删除采集绑定
     *
     * @param bindIds 需要删除的绑定ID
     * @return 结果
     */
    @Override
    public int deleteCollectBindByIds(Long[] bindIds) {
        return collectBindMapper.deleteCollectBindByIds(bindIds);
    }

    /**
     * 删除采集绑定
     *
     * @param bindId 绑定ID
     * @return 结果
     */
    @Override
    public int deleteCollectBindById(Long bindId) {
        return collectBindMapper.deleteCollectBindById(bindId);
    }

    /**
     * 根据站点ID获取绑定
     *
     * @param siteId 站点ID
     * @return 绑定列表
     */
    @Override
    public List<CollectBind> selectBindsBySiteId(Long siteId) {
        CollectBind query = new CollectBind();
        query.setSiteId(siteId);
        return selectCollectBindList(query);
    }

    /**
     * 获取绑定映射表便于快速查找
     *
     * @param siteId 站点ID
     * @return 以远程类型ID为键的映射表
     */
    @Override
    public Map<String, CollectBind> getBindingMap(Long siteId) {
        CollectBind query = new CollectBind();
        query.setSiteId(siteId);
        query.setBindStatus("0"); // 只查询已绑定状态
        query.setStatus("0"); // 只查询正常状态
        List<CollectBind> binds =  selectCollectBindList(query);
        Map<String, CollectBind> bindMap = new HashMap<>();
        for (CollectBind bind : binds) {
            bindMap.put(bind.getRemoteTypeId(), bind);
        }
        return bindMap;
    }

    /**
     * 从远程站点自动绑定类型（智能匹配）
     *
     * @param siteId 站点ID
     * @return 创建的绑定数量
     */
    @Override
    public int autoBindTypes(Long siteId) {
        try {
            CollectSite site = collectSiteService.selectCollectSiteById(siteId);
            if (site == null) {
                log.error("站点不存在: {}", siteId);
                return 0;
            }

            // 获取远程类型
            List<MacCmsResponse.TypeInfo> remoteTypes = macCmsApiClient.getTypeList(site.getSiteUrl());
            if (remoteTypes == null || remoteTypes.isEmpty()) {
                log.warn("站点 {} 没有远程类型", site.getSiteName());
                return 0;
            }

            // 获取本地所有栏目
            com.ruoyi.basic.domain.Column columnQuery = new com.ruoyi.basic.domain.Column();
            columnQuery.setStatus("0"); // 只查询正常状态
            List<com.ruoyi.basic.domain.Column> localColumns = columnService.selectColumnList(columnQuery);

            // 创建名称到Column的映射（用于快速匹配）
            Map<String, com.ruoyi.basic.domain.Column> nameToColumnMap = new HashMap<>();
            for (com.ruoyi.basic.domain.Column column : localColumns) {
                if (column.getName() != null) {
                    nameToColumnMap.put(column.getName().trim(), column);
                }
            }

            // 检查现有绑定
            Map<String, CollectBind> existingBinds = getBindingMap(siteId);

            int created = 0;
            int matched = 0;

            for (MacCmsResponse.TypeInfo typeInfo : remoteTypes) {
                String remoteTypeId = typeInfo.getTypeId();
                String remoteTypeName = typeInfo.getTypeName();

                if (existingBinds.containsKey(remoteTypeId)) {
                    // 已存在绑定，检查是否需要智能匹配
                    CollectBind existBind = existingBinds.get(remoteTypeId);

                    // 如果未绑定本地栏目，尝试智能匹配
                    if (existBind.getLocalTypeId() == null && remoteTypeName != null) {
                        com.ruoyi.basic.domain.Column matchedColumn = nameToColumnMap.get(remoteTypeName.trim());
                        if (matchedColumn != null) {
                            existBind.setLocalTypeId(matchedColumn.getColumnId().longValue());
                            existBind.setLocalTypeName(matchedColumn.getName());
                            existBind.setLocalColumn(matchedColumn.getValue());
                            existBind.setBindStatus("0"); // 设为已绑定
                            updateCollectBind(existBind);
                            matched++;
                            log.info("智能匹配：{} → {} (ID:{})", remoteTypeName, matchedColumn.getName(), matchedColumn.getColumnId());
                        }
                    }
                } else {
                    // 新增绑定并尝试智能匹配
                    CollectBind bind = new CollectBind();
                    bind.setSiteId(siteId);
                    bind.setSiteFlag(site.getSiteFlag());
                    bind.setRemoteTypeId(remoteTypeId);
                    bind.setRemoteTypeName(remoteTypeName);
                    bind.setResourceType("1"); // 影视
                    bind.setStatus("0"); // 活动

                    // 尝试智能匹配本地栏目
                    if (remoteTypeName != null) {
                        com.ruoyi.basic.domain.Column matchedColumn = nameToColumnMap.get(remoteTypeName.trim());
                        if (matchedColumn != null) {
                            bind.setLocalTypeId(matchedColumn.getColumnId().longValue());
                            bind.setLocalTypeName(matchedColumn.getName());
                            bind.setLocalColumn(matchedColumn.getValue());
                            bind.setBindStatus("0"); // 已绑定
                            matched++;
                            log.info("智能匹配：{} → {} (ID:{})", remoteTypeName, matchedColumn.getName(), matchedColumn.getColumnId());
                        } else {
                            bind.setBindStatus("1"); // 未绑定
                        }
                    } else {
                        bind.setBindStatus("1"); // 未绑定
                    }

                    insertCollectBind(bind);
                    created++;
                }
            }

            log.info("为站点 {} 创建了 {} 个类型绑定，智能匹配 {} 个", site.getSiteName(), created, matched);
            return created;
        } catch (Exception e) {
            log.error("站点 {} 自动绑定类型失败: {}", siteId, e.getMessage(), e);
            return 0;
        }
    }

    /**
     * 清除站点的所有绑定
     *
     * @param siteId 站点ID
     * @return 删除的绑定数量
     */
    @Override
    public int clearSiteBindings(Long siteId) {
        List<CollectBind> binds = selectBindsBySiteId(siteId);
        if (binds.isEmpty()) {
            return 0;
        }

        Long[] bindIds = binds.stream()
                .map(CollectBind::getBindId)
                .toArray(Long[]::new);

        return deleteCollectBindByIds(bindIds);
    }

    /**
     * 同步采集站点的分类列表
     *
     * @param siteId 站点ID
     * @return 同步结果（成功数量、失败数量等）
     */
    @Override
    public Map<String, Object> syncTypeList(Long siteId) {
        Map<String, Object> result = new HashMap<>();
        result.put("success", false);
        result.put("newCount", 0);
        result.put("existCount", 0);
        result.put("totalCount", 0);

        try {
            CollectSite site = collectSiteService.selectCollectSiteById(siteId);
            if (site == null) {
                result.put("message", "站点不存在");
                log.error("站点不存在: {}", siteId);
                return result;
            }

            // 获取远程类型列表
            log.info("正在从站点 {} 获取分类列表", site.getSiteName());
            List<MacCmsResponse.TypeInfo> remoteTypes = macCmsApiClient.getTypeList(site.getSiteUrl());

            if (remoteTypes == null || remoteTypes.isEmpty()) {
                result.put("message", "未获取到分类列表");
                log.warn("站点 {} 未获取到分类列表", site.getSiteName());
                return result;
            }

            result.put("totalCount", remoteTypes.size());
            log.info("获取到 {} 个分类", remoteTypes.size());

            // 检查现有绑定
            Map<String, CollectBind> existingBinds = getBindingMap(siteId);

            int newCount = 0;
            int existCount = 0;

            for (MacCmsResponse.TypeInfo typeInfo : remoteTypes) {
                if (existingBinds.containsKey(typeInfo.getTypeId())) {
                    // 更新已存在的绑定名称
                    CollectBind existBind = existingBinds.get(typeInfo.getTypeId());
                    if (!typeInfo.getTypeName().equals(existBind.getRemoteTypeName())) {
                        existBind.setRemoteTypeName(typeInfo.getTypeName());
                        updateCollectBind(existBind);
                    }
                    existCount++;
                } else {
                    // 创建新绑定
                    CollectBind bind = new CollectBind();
                    bind.setSiteId(siteId);
                    bind.setSiteFlag(site.getSiteFlag());
                    bind.setRemoteTypeId(typeInfo.getTypeId());
                    bind.setRemoteTypeName(typeInfo.getTypeName());
                    bind.setResourceType(site.getResourceType());
                    bind.setBindStatus("1"); // 未绑定
                    bind.setStatus("0"); // 正常

                    insertCollectBind(bind);
                    newCount++;
                }
            }

            result.put("success", true);
            result.put("newCount", newCount);
            result.put("existCount", existCount);
            result.put("message", String.format("同步成功：新增%d个，已存在%d个", newCount, existCount));

            log.info("站点 {} 同步分类完成：新增 {} 个，已存在 {} 个",
                site.getSiteName(), newCount, existCount);

        } catch (Exception e) {
            result.put("message", "同步失败：" + e.getMessage());
            log.error("站点 {} 同步分类失败: {}", siteId, e.getMessage(), e);
        }

        return result;
    }

    /**
     * 获取站点已绑定的源分类ID集合（用于采集过滤）
     *
     * @param siteId 站点ID
     * @return 已绑定的源分类ID集合
     */
    @Override
    public java.util.Set<String> getBoundSourceTypeIds(Long siteId) {
        java.util.Set<String> boundTypeIds = new java.util.HashSet<>();

        CollectBind query = new CollectBind();
        query.setSiteId(siteId);
        query.setBindStatus("0"); // 只查询已绑定状态
        query.setStatus("0"); // 只查询正常状态

        List<CollectBind> binds = selectCollectBindList(query);

        for (CollectBind bind : binds) {
            if (bind.getRemoteTypeId() != null && !bind.getRemoteTypeId().isEmpty()) {
                boundTypeIds.add(bind.getRemoteTypeId());
            }
        }

        log.debug("站点 {} 已绑定 {} 个类型: {}", siteId, boundTypeIds.size(), boundTypeIds);
        return boundTypeIds;
    }

    /**
     * 批量绑定分类
     *
     * @param bindList 绑定列表
     * @return 绑定结果
     */
    @Override
    public int batchBindTypes(List<CollectBind> bindList) {
        if (bindList == null || bindList.isEmpty()) {
            return 0;
        }

        int count = 0;
        for (CollectBind bind : bindList) {
            try {
                if (bind.getBindId() != null) {
                    // 更新现有绑定
                    updateCollectBind(bind);
                } else {
                    // 插入新绑定
                    insertCollectBind(bind);
                }
                count++;
            } catch (Exception e) {
                log.error("批量绑定失败: {}", e.getMessage());
            }
        }

        log.info("批量绑定完成: 成功 {} 个", count);
        return count;
    }
}
